# Projet 15 Voiture Intelligente Contrôlée par Bluetooth
### **1.Description**
Nous avons appris les connaissances de base sur le Bluetooth. Dans cette leçon, nous allons fabriquer une voiture intelligente contrôlée par Bluetooth. Dans ce projet, nous considérons le téléphone mobile comme l’émetteur (hôte), et la voiture intelligente connectée au module Bluetooth BT24 (esclave) comme le récepteur, et utilisons l’application mobile pour contrôler la voiture intelligente via le Bluetooth.
### **2.Boutons de Contrôle de l’APP**
| | Caractère de contrôle | Caractère de contrôle |
| ------------------------- | ---------------------------------------------------------- | ---------------------------------------------------------- |
|  | Appui : F
Relâchement : S | Appuyez sur le bouton, la voiture avance ;
relâchez pour arrêter |
|  | Appui : L
Relâchement : S | Appuyez sur le bouton, la voiture tourne à gauche ;
relâchez pour arrêter |
|  | Appui : R
Relâchement : S | Appuyez sur le bouton, la voiture tourne à droite ;
relâchez pour arrêter |
|  | Appui : B
Relâchement : S | Appuyez sur le bouton, la voiture recule ;
relâchez pour arrêter |
|  | Appui : “a”
Relâchement : “S” | Cliquez pour accélérer (maximum : 255) |
|  | Appui : “d”
Relâchement : “S” | Cliquez pour ralentir (minimum : 0) |
|  | Cliquez pour démarrer la fonction de détection
de gravité du téléphone mobile : cliquez de nouveau pour
quitter le contrôle par détection de gravité | |
|  | Cliquez pour envoyer “X”,
cliquez de nouveau pour envoyer “S” | Démarrer la fonction de suivi de ligne ;
cliquez de nouveau pour quitter |
|  | Cliquez pour envoyer “Y”,
cliquez de nouveau pour envoyer “S” | Démarrer la fonction d’évitement ultrasonique ;
cliquez de nouveau pour quitter |
|  | Cliquez pour envoyer “U”,
cliquez de nouveau pour envoyer “S” | Démarrer la fonction de suivi ultrasonique ;
cliquez de nouveau pour quitter |
|  | Cliquez pour envoyer “G”,
cliquez de nouveau pour envoyer “S” | Démarrer la fonction de restriction ;
cliquez de nouveau pour quitter |
### **3.Diagramme de Flux**
### **4.Schéma de Câblage**
1). GND, VCC, SDA et SCL de la carte LED 8\*8 sont connectés à G (GND), V (VCC), A4 et A5 de la carte d’extension.
2). Les broches RXD, TXD, GND et VCC du module Bluetooth sont respectivement connectées à TX, RX, G et 5V sur le Shield moteur 8833, tandis que les broches STATE et BRK du module Bluetooth n’ont pas besoin d’être connectées.
3). Le servo est connecté à G, V et A3. Le fil marron est connecté à Gnd (G), le fil rouge est connecté à 5V (V) et le fil orange est connecté à A3.
4). L’alimentation est connectée au port BAT
### **5.Code de Test**
**Note :** Avant de téléverser le code de test, vous devez retirer le module Bluetooth, sinon le code ne pourra pas être téléversé. Reconnectez le module Bluetooth après avoir téléversé le code avec succès.
```c
//*******************************************************************************
/*
keyestudio 4wd BT Car
leçon 15
Contrôle Bluetooth de la voiture
http://www.keyestudio.com
*/
#define SCL_Pin A5 //Définir la broche d'horloge sur A5
#define SDA_Pin A4 //Définir la broche de données sur A4
//Tableau, utilisé pour stocker les données du motif, peut être calculé par vous-même ou obtenu à partir de l'outil modulus
unsigned char start01[] = {0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01};
unsigned char front[] = {0x00,0x00,0x00,0x00,0x00,0x24,0x12,0x09,0x12,0x24,0x00,0x00,0x00,0x00,0x00,0x00};
unsigned char back[] = {0x00,0x00,0x00,0x00,0x00,0x24,0x48,0x90,0x48,0x24,0x00,0x00,0x00,0x00,0x00,0x00};
unsigned char left[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x44,0x28,0x10,0x44,0x28,0x10,0x44,0x28,0x10,0x00};
unsigned char right[] = {0x00,0x10,0x28,0x44,0x10,0x28,0x44,0x10,0x28,0x44,0x00,0x00,0x00,0x00,0x00,0x00};
unsigned char STOP01[] = {0x2E,0x2A,0x3A,0x00,0x02,0x3E,0x02,0x00,0x3E,0x22,0x3E,0x00,0x3E,0x0A,0x0E,0x00};
unsigned char clear[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
int left_ctrl = 2;//définir les broches de contrôle de direction du moteur du groupe B
int left_pwm = 5;//définir les broches de contrôle PWM du moteur du groupe B
int right_ctrl = 4;//définir les broches de contrôle de direction du moteur du groupe A
int right_pwm = 6;//définir les broches de contrôle PWM du moteur du groupe A
const int servopin = A3;//définir la broche du servo sur A3
char BLE_val;
void setup() {
Serial.begin(9600);//
pinMode(left_ctrl,OUTPUT);//définir les broches de contrôle de direction du moteur du groupe B en OUTPUT
pinMode(left_pwm,OUTPUT);//définir les broches de contrôle PWM du moteur du groupe B en OUTPUT
pinMode(right_ctrl,OUTPUT);//définir les broches de contrôle de direction du moteur du groupe A en OUTPUT
pinMode(right_pwm,OUTPUT);//définir les broches de contrôle PWM du moteur du groupe A en OUTPUT
servopulse(servopin,90);//l'angle du servo est de 90 degrés
delay(300);
pinMode(SCL_Pin,OUTPUT);//Définir la broche d'horloge en sortie
pinMode(SDA_Pin,OUTPUT);//Définir la broche de données en sortie
matrix_display(clear);
matrix_display(start01); //afficher le motif start01
}
void loop() {
if(Serial.available()>0) {
BLE_val = Serial.read();
Serial.println(BLE_val);
}
switch(BLE_val)
{
case 'F' : car_front(); //Reçoit 'F', la voiture avance
matrix_display(clear);
matrix_display(front);
break;
case 'B' : car_back(); //Reçoit 'B', la voiture recule
matrix_display(clear);
matrix_display(back);
break;
case 'L' : car_left(); //Reçoit 'L', la voiture tourne à gauche
matrix_display(clear);
matrix_display(left);
break;
case 'R' : car_right();//Reçoit 'R', la voiture tourne à droite
matrix_display(clear);
matrix_display(right);
break;
case 'S' : car_Stop();//Reçoit 'S', la voiture s'arrête
matrix_display(clear);
matrix_display(STOP01);
break;
}
}
void car_front()//définir l'état d'avancer
{
digitalWrite(left_ctrl,HIGH);
analogWrite(left_pwm,155);
digitalWrite(right_ctrl,HIGH);
analogWrite(right_pwm,155);
}
void car_back()//définir l'état de recul
{
digitalWrite(left_ctrl,LOW);
analogWrite(left_pwm,100);
digitalWrite(right_ctrl,LOW);
analogWrite(right_pwm,100);
}
void car_left()//définir l'état de rotation à gauche
{
digitalWrite(left_ctrl, LOW);
analogWrite(left_pwm, 100);
digitalWrite(right_ctrl, HIGH);
analogWrite(right_pwm, 155);
}
void car_right()//définir l'état de rotation à droite
{
digitalWrite(left_ctrl, HIGH);
analogWrite(left_pwm, 155);
digitalWrite(right_ctrl, LOW);
analogWrite(right_pwm, 100);
}
void car_Stop()//définir l'état d'arrêt
{
digitalWrite(left_ctrl,LOW);
analogWrite(left_pwm,0);
digitalWrite(right_ctrl,LOW);
analogWrite(right_pwm,0);
}
void servopulse(int servopin,int myangle)//Angle de fonctionnement du servo-moteur
{
for(int i=0; i<30; i++)
{
int pulsewidth = (myangle*11)+500;
digitalWrite(servopin,HIGH);
delayMicroseconds(pulsewidth);
digitalWrite(servopin,LOW);
delay(20-pulsewidth/1000);
}
}
//cette fonction est utilisée pour l'affichage matriciel
void matrix_display(unsigned char matrix_value[])
{
IIC_start(); //la fonction qui appelle la condition de démarrage du transfert de données
IIC_send(0xc0); //sélectionner l'adresse
for (int i = 0; i < 16; i++) //les données du motif sont de 16 octets
{
IIC_send(matrix_value[i]); //Transmettre les données du motif
}
IIC_end(); //Fin de la transmission des données du motif
IIC_start();
IIC_send(0x8A); //Contrôle de l'affichage, sélection de la largeur d'impulsion 4/16
IIC_end();
}
//Conditions sous lesquelles la transmission des données commence
void IIC_start()
{
digitalWrite(SDA_Pin, HIGH);
digitalWrite(SCL_Pin, HIGH);
delayMicroseconds(3);
digitalWrite(SDA_Pin, LOW);
delayMicroseconds(3);
digitalWrite(SCL_Pin, LOW);
}
//Indique la fin de la transmission des données
void IIC_end()
{
digitalWrite(SCL_Pin, LOW);
digitalWrite(SDA_Pin, LOW);
delayMicroseconds(3);
digitalWrite(SCL_Pin, HIGH);
delayMicroseconds(3);
digitalWrite(SDA_Pin, HIGH);
delayMicroseconds(3);
}
//transmettre les données
void IIC_send(unsigned char send_data)
{
for (byte mask = 0x01; mask != 0; mask <<= 1) //Chaque octet a 8 bits et est vérifié bit par bit en commençant par le niveau le plus bas
{
if (send_data & mask) { //Définit les niveaux haut et bas de SDA_Pin selon que chaque bit de l'octet est un 1 ou un 0
digitalWrite(SDA_Pin, HIGH);
} else {
digitalWrite(SDA_Pin, LOW);
}
delayMicroseconds(3);
digitalWrite(SCL_Pin, HIGH); //Met la broche d'horloge SCL_Pin à haut pour arrêter la transmission des données
delayMicroseconds(3);
digitalWrite(SCL_Pin, LOW); //met la broche d'horloge SCL_Pin à bas pour changer le SIGNAL de SDA
}
}
//*******************************************************************************
```
### **6.Résultat du test**
Après avoir téléchargé avec succès le code sur la carte V4.0, connectez les câblages selon le schéma de câblage, alimentez l'alimentation externe puis mettez l'interrupteur DIP sur ON.
Insérez le module BT et ouvrez votre téléphone portable pour connecter le Bluetooth afin de contrôler la voiture intelligente. La voiture avancera, reculera, tournera à gauche et à droite et s'arrêtera. De plus, la carte LED 8\*8 affichera les motifs correspondants.